{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### index:\n",
    "- python 基础编程（数据运算 比较运算 赋值运算 逻辑运算 成员运算）\n",
    "- python 流程控制（if 分支控制 for 循环控制）\n",
    "- python  函数（模块）设计\n",
    "- python 编程库（包）的导入\n",
    "- **python基础统合实践**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据：\n",
    "http://pan.baidu.com/s/1dENAUTr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 源码：\n",
    "http://pan.baidu.com/s/1geN6QbD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python 编程基础"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注：使用中文输入法输入的运算符号 会出现报错情况"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "python数据运算 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#整数运算\n",
    "10+20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-30.5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#整数与浮点数减法\n",
    "30-60.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35.6"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#整数与浮点数乘法\n",
    "4*8.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.25"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#整数与整数相除\n",
    "5/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#整数取模运算\n",
    "5%4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#幂指数运算\n",
    "2.0**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "比较运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#整数比较\n",
    "10<20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " 10>20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#整数与浮点数比较\n",
    "30<30.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "30<=30.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "30.0<=30.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#判断两个值是否相等\n",
    "30==40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#判断两个值不想等\n",
    "30!=40"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "赋值运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将一些数据赋值给自定义的变量，python在声明变量时不需要预告知类型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#将一个元组赋值给变量t\n",
    "t= (1,'abc',0.4)\n",
    "#下列代码数错误的因为我们都知道 元组内部元素是不可以修改的\n",
    "#t[0]=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 'abc', 0.4]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#将一个列表赋值给变量l\n",
    "l=[1,'abc',0.4]\n",
    "#试图更改列表l的第一个元素\n",
    "l[0]=2\n",
    "l[0]+=1\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "逻辑运算 与（and） 或（or）非（not）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#与 二者都是true才能 true\n",
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#或 有一个是true 就是true\n",
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#非 取得相反的布尔值\n",
    "not False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "成员运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "主要是面向元组 列表 字典。\n",
    "通过运算符in询问是否有某个元素在元组或者列表里面出现，或者检视某个键（key）是否在字典里存在。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 一个列表一个元组一个字典\n",
    "l=[1,'abc',0.4]\n",
    "t= (1,'abc',0.4)\n",
    "d={1:'1','abc':0.1,0.4:80}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#询问列表l中是否有0.4\n",
    "0.4 in l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#询问元组t中是否有1\n",
    "1 in t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#询问字典d中是否有键‘abc’\n",
    "'adc' in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#in 只能用来考量是否有键值（key） 不能告诉你是否有值（value）\n",
    "0.1 in d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python 流程控制"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分支语句 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is True!\n"
     ]
    }
   ],
   "source": [
    "b = False\n",
    "c = True \n",
    "if b:\n",
    "    print (\"b is True!\")\n",
    "elif c:\n",
    "    print (\"c is True!\")\n",
    "else:\n",
    "    print (\"Both are False!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "循环控制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 : 1\n",
      "abc : 0.1\n",
      "0.4 : 80\n"
     ]
    }
   ],
   "source": [
    "#对字典d的键进行循环遍历，输出每组键值对\n",
    "d={1:'1','abc':0.1,0.4:80}\n",
    "for k in d:\n",
    "    print(k,':',d[k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python函数（模块）设计"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 关键字def\n",
    "#定义一个名为foo的函数 传入参数x。\n",
    "def foo(x):\n",
    "    return x**2\n",
    "#调用函数foo 传入参数为8.0 观察输出\n",
    "foo(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python 编程库（包）的导入"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.38905609893065"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#直接使用import导入math工具包\n",
    "import math\n",
    "#调用math包下的exp函数求自然指数\n",
    "#exp() 方法返回x的指数,e的x幂\n",
    "math.exp(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.38905609893065"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#从（from） math工具包里指定导入exphanshu，并且对exp 函数重新明名为ep\n",
    "from math import exp as ep\n",
    "#使用函数exp的临时代替名称调用\n",
    "ep(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# python基础统合实践"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings#忽略警告\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#导入pandas工具包，并且更名为pd。\n",
    "import pandas as pd\n",
    "#调用pandas工具包的 read_csv 函数/模块，传入训练/测试文件的地址，获得返回的数据并且存至变量df_train/df_test\n",
    "df_train = pd.read_csv(\"breast-cancer-train.csv\")\n",
    "df_test=pd.read_csv(\"breast-cancer-test.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Unnamed: 0', 'Clump Thickness', 'Cell Size', 'Type'], dtype='object')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 看一下测试数据的列名\n",
    "df_test.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#选取'Clump Thickness'和'Type' 特征作为测试数据\n",
    "df_test=df_test[['Clump Thickness','Cell Size', 'Type']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Clump Thickness</th>\n",
       "      <th>Cell Size</th>\n",
       "      <th>Type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Clump Thickness  Cell Size  Type\n",
       "0                1          2     0\n",
       "1                1          1     0\n",
       "2                1          1     0\n",
       "3                5          5     1\n",
       "4                1          1     0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#看前面5行\n",
    "df_test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#把测试数据的正负样本分开\n",
    "#恶心肿瘤\n",
    "df_test_nagative=df_test[df_test['Type']==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Clump Thickness</th>\n",
       "      <th>Cell Size</th>\n",
       "      <th>Type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Clump Thickness  Cell Size  Type\n",
       "0                1          2     0\n",
       "1                1          1     0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test_nagative.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#良性肿瘤\n",
    "df_test_positive=df_test[df_test['Type']==1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Clump Thickness</th>\n",
       "      <th>Cell Size</th>\n",
       "      <th>Type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Clump Thickness  Cell Size  Type\n",
       "3                5          5     1\n",
       "7                6          6     1"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test_positive.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "#导入matplotlib工具包中的pyplot 并命名为plt\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function scatter in module matplotlib.pyplot:\n",
      "\n",
      "scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, edgecolors=None, hold=None, data=None, **kwargs)\n",
      "    Make a scatter plot of `x` vs `y`.\n",
      "    \n",
      "    Marker size is scaled by `s` and marker color is mapped to `c`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    x, y : array_like, shape (n, )\n",
      "        Input data\n",
      "    \n",
      "    s : scalar or array_like, shape (n, ), optional\n",
      "        size in points^2.  Default is `rcParams['lines.markersize'] ** 2`.\n",
      "    \n",
      "    c : color, sequence, or sequence of color, optional, default: 'b'\n",
      "        `c` can be a single color format string, or a sequence of color\n",
      "        specifications of length `N`, or a sequence of `N` numbers to be\n",
      "        mapped to colors using the `cmap` and `norm` specified via kwargs\n",
      "        (see below). Note that `c` should not be a single numeric RGB or\n",
      "        RGBA sequence because that is indistinguishable from an array of\n",
      "        values to be colormapped.  `c` can be a 2-D array in which the\n",
      "        rows are RGB or RGBA, however, including the case of a single\n",
      "        row to specify the same color for all points.\n",
      "    \n",
      "    marker : `~matplotlib.markers.MarkerStyle`, optional, default: 'o'\n",
      "        See `~matplotlib.markers` for more information on the different\n",
      "        styles of markers scatter supports. `marker` can be either\n",
      "        an instance of the class or the text shorthand for a particular\n",
      "        marker.\n",
      "    \n",
      "    cmap : `~matplotlib.colors.Colormap`, optional, default: None\n",
      "        A `~matplotlib.colors.Colormap` instance or registered name.\n",
      "        `cmap` is only used if `c` is an array of floats. If None,\n",
      "        defaults to rc `image.cmap`.\n",
      "    \n",
      "    norm : `~matplotlib.colors.Normalize`, optional, default: None\n",
      "        A `~matplotlib.colors.Normalize` instance is used to scale\n",
      "        luminance data to 0, 1. `norm` is only used if `c` is an array of\n",
      "        floats. If `None`, use the default :func:`normalize`.\n",
      "    \n",
      "    vmin, vmax : scalar, optional, default: None\n",
      "        `vmin` and `vmax` are used in conjunction with `norm` to normalize\n",
      "        luminance data.  If either are `None`, the min and max of the\n",
      "        color array is used.  Note if you pass a `norm` instance, your\n",
      "        settings for `vmin` and `vmax` will be ignored.\n",
      "    \n",
      "    alpha : scalar, optional, default: None\n",
      "        The alpha blending value, between 0 (transparent) and 1 (opaque)\n",
      "    \n",
      "    linewidths : scalar or array_like, optional, default: None\n",
      "        If None, defaults to (lines.linewidth,).\n",
      "    \n",
      "    verts : sequence of (x, y), optional\n",
      "        If `marker` is None, these vertices will be used to\n",
      "        construct the marker.  The center of the marker is located\n",
      "        at (0,0) in normalized units.  The overall marker is rescaled\n",
      "        by ``s``.\n",
      "    \n",
      "    edgecolors : color or sequence of color, optional, default: None\n",
      "        If None, defaults to 'face'\n",
      "    \n",
      "        If 'face', the edge color will always be the same as\n",
      "        the face color.\n",
      "    \n",
      "        If it is 'none', the patch boundary will not\n",
      "        be drawn.\n",
      "    \n",
      "        For non-filled markers, the `edgecolors` kwarg\n",
      "        is ignored and forced to 'face' internally.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    paths : `~matplotlib.collections.PathCollection`\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    **kwargs : `~matplotlib.collections.Collection` properties\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    plot : to plot scatter plots when markers are identical in size and\n",
      "        color\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    \n",
      "    * The `plot` function will be faster for scatterplots where markers\n",
      "      don't vary in size or color.\n",
      "    \n",
      "    * Any or all of `x`, `y`, `s`, and `c` may be masked arrays, in which\n",
      "      case all masks will be combined and only unmasked points will be\n",
      "      plotted.\n",
      "    \n",
      "      Fundamentally, scatter works with 1-D arrays; `x`, `y`, `s`, and `c`\n",
      "      may be input as 2-D arrays, but within scatter they will be\n",
      "      flattened. The exception is `c`, which will be flattened only if its\n",
      "      size matches the size of `x` and `y`.\n",
      "    \n",
      "    .. note::\n",
      "        In addition to the above described arguments, this function can take a\n",
      "        **data** keyword argument. If such a **data** argument is given, the\n",
      "        following arguments are replaced by **data[<arg>]**:\n",
      "    \n",
      "        * All arguments with the following names: 'c', 'color', 'edgecolors', 'facecolor', 'facecolors', 'linewidths', 's', 'x', 'y'.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#help函数 \n",
    "help(plt.scatter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fae86ed8160>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fae8700b5f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xlabel('Clump Thickness')#x轴名称\n",
    "plt.ylabel('Cell Size')#y轴名称\n",
    "#绘制良性肿瘤样本点 标记为红色的。\n",
    "plt.scatter(df_test_positive['Clump Thickness'],df_test_positive['Cell Size'],marker='o',s=200,c='red')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fae870759b0>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fae86ec7f98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xlabel('Clump Thickness')\n",
    "plt.ylabel('Cell Size')\n",
    "#绘制恶性肿瘤样本点 标记为蓝色的。\n",
    "plt.scatter(df_test_nagative['Clump Thickness'],df_test_nagative['Cell Size'],marker='x',s=200,c='blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#绘制一条直线\n",
    "import numpy as np\n",
    "intercept = np.random.random([1]) #随机初始化截距\n",
    "coef=np.random.random([2])#随机初始化系数\n",
    "lx=np.arange(0,12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.1024919])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.73044324, 0.28469882])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coef"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lx=np.arange(0,12)#输入x\n",
    "lx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "ly=(-intercept-lx*coef[0])/coef[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -0.36000114,  -2.92567122,  -5.49134129,  -8.05701137,\n",
       "       -10.62268144, -13.18835151, -15.75402159, -18.31969166,\n",
       "       -20.88536174, -23.45103181, -26.01670188, -28.58237196])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fae7d800cc0>]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fae7d5f2588>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#绘制这条直线\n",
    "plt.plot(lx,ly,c='yellow')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fae7d69ffd0>]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fae7d5ed080>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xlabel('Clump Thickness')\n",
    "plt.ylabel('Cell Size')\n",
    "plt.scatter(df_test_nagative['Clump Thickness'],df_test_nagative['Cell Size'],marker='x',s=200,c='blue')\n",
    "plt.scatter(df_test_positive['Clump Thickness'],df_test_positive['Cell Size'],marker='o',s=200,c='red')\n",
    "plt.plot(lx,ly,c='yellow')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "#导入LogisticRegression分类模型\n",
    "#模型是一条直线\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "lr=LogisticRegression()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n",
       "          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n",
       "          verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#使用训练数据训练模型的参数 即系数和截距\n",
    "lr.fit(df_train[['Clump Thickness','Cell Size']],df_train[['Type']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9371428571428572"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#看训练后的模型在测试集上面的准确率\n",
    "lr.score(df_test[['Clump Thickness','Cell Size']],df_test[['Type']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "intercept=lr.intercept_\n",
    "coef=lr.coef_[0,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "ly=(-intercept-lx*coef[0])/coef[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fae725715f8>"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fae724f2470>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(lx,ly,c='green')\n",
    "plt.xlabel('Clump Thickness')\n",
    "plt.ylabel('Cell Size')\n",
    "plt.scatter(df_test_nagative['Clump Thickness'],df_test_nagative['Cell Size'],marker='x',s=200,c='blue')\n",
    "plt.scatter(df_test_positive['Clump Thickness'],df_test_positive['Cell Size'],marker='o',s=200,c='red')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
